home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 8: LINUX Games / Linux Cubed Series 8 - LINUX Games.iso / games / video / fly8111-.000 / fly8111- / fly8 / btrail.c < prev    next >
C/C++ Source or Header  |  1979-12-31  |  4KB  |  141 lines
  1. /* --------------------------------- btrail.c ------------------------------- */
  2.  
  3. /* This is part of the flight simulator 'fly8'.
  4.  * Author: Eyal Lebedinsky (eyal@ise.canberra.edu.au).
  5. */
  6.  
  7. /* paint the bullet trail history on the Head Up Display.
  8. */
  9.  
  10. #include "plane.h"
  11.  
  12.  
  13. /* Show bullets trail history.
  14.  *
  15.  * -d0 and P[] is the previous point distance and position.
  16.  * -d1 and Q[] is the currect  point distance and position.
  17.  * -d  and R[] is the needed   point distance and position.
  18.  * -d takes the values of the displayed points, which start at the closest
  19.  * (BULMIN) and end at the farthest (BULMAX) in equal steps (BULSEG). The
  20.  * points some intervals (BULSTEP) are marked with a small bar while the
  21.  * target distance (ddd) is marked with a tiny bead.
  22.  * -R[] is interpolated from P[] and Q[].
  23. */
  24.  
  25. #define BULSEG    (int)(750/3.28)        /* segment size (meters) */
  26. #define BULSTEP    (2*BULSEG)        /* marked step size */
  27. #define BULMIN    (BULSEG/2)        /* nearest point shown */
  28. #define BULMAX    (3*BULSTEP)        /* farthest point shown */
  29.  
  30. extern void FAR
  31. show_trail (HUD *h, VIEW *view, OBJECT *p)
  32. {
  33.     OBJECT        *target;
  34.     BTRAIL        *h1, *h2;
  35.     VECT        P, Q, R, V;
  36.     int        D1[2], D2[2];
  37.     int        d, n, d0, d1, dd, dd0, dd1, ddd;
  38.     int        t, off, tx, ty, first;
  39.  
  40.     if (!(EX->hud2 & HUD_BTRAIL))
  41.         return;
  42.  
  43.     if (T(target = EX->target)) {
  44.         ddd = (int)(ldist3d (p->R, target->R)/VONE);
  45.         if (ddd > BULMAX)
  46.             ddd = BULMAX;
  47.     } else
  48.         ddd = BULMAX;
  49.     tx = fmul (h->sx, F16RBUL);
  50.     ty = fmul (h->sy, F16RBUL);
  51.     D1[X] = h->orgx;
  52.     D1[Y] = h->orgy;
  53.     off = 0;
  54.     if (ddd < BULSEG) {
  55.         n = BULSEG;
  56.         d = ddd;
  57.     } else {
  58.         d = BULSEG;
  59.         n = d + BULSEG;
  60.     }
  61.     gr_color (ST_HFG);
  62.     first = 1;
  63.     for (h2 = 0, h1 = EX->btrail; h1; h2 = h1, h1 = h1->next) {
  64.  
  65. /* find first point with a distance (d1) >= the desired segment (d).
  66. */
  67.         if ((d1 = (int)(ldist3d (p->R, h1->R)/VONE)) < d)
  68.             continue;
  69.         t = 1 + d1/1000;
  70.         if (h2) {
  71.             d0 = (int)(ldist3d (p->R, h2->R)/VONE);
  72.             P[X] = (int)((h2->R[X] - p->R[X])/t);
  73.             P[Y] = (int)((h2->R[Y] - p->R[Y])/t);
  74.             P[Z] = (int)((h2->R[Z] - p->R[Z])/t);
  75.         } else {
  76.             d0 = 0;
  77.             P[X] = P[Y] = P[Z] = 0;
  78.         }
  79.         Q[X] = (int)((h1->R[X] - p->R[X])/t);
  80.         Q[Y] = (int)((h1->R[Y] - p->R[Y])/t);
  81.         Q[Z] = (int)((h1->R[Z] - p->R[Z])/t);
  82. l1:
  83.         dd  = d1 - d0;            /* segment size */
  84.         dd0 = d  - d0;            /* leading part */
  85.         dd1 = d1 - d;            /* trailing part */
  86.  
  87.         if (d1 <= d0 || d < d0 || d1 < d) {
  88. LogPrintf ("show_trail> %d, %d, %d\n", d0, d, d1);
  89. ++STATS_DEBUG;
  90.             break;
  91.         }
  92.         R[X] = muldiv (Q[X], dd0, dd) + muldiv (P[X], dd1, dd);
  93.         R[Y] = muldiv (Q[Y], dd0, dd) + muldiv (P[Y], dd1, dd);
  94.         R[Z] = muldiv (Q[Z], dd0, dd) + muldiv (P[Z], dd1, dd);
  95.  
  96.         VxMmul (V, R, p->T);
  97.         screen_coords (view, V);
  98.         off = clip_to_screen (D2, V, h->maxx, h->maxy, h->clipx-tx,
  99.             h->clipy-ty, h->shifty);
  100.         if (first && d > BULMIN) {
  101.             D1[X] = muldiv (D2[X], BULMIN, d);
  102.             D1[Y] = muldiv (D2[Y], BULMIN, d);
  103.             D1[X] = h->orgx + D1[X];
  104.             D1[Y] = h->orgy - D1[Y];
  105.         }
  106.         D2[X] = h->orgx + D2[X];
  107.         D2[Y] = h->orgy - D2[Y];
  108.         add_segment (D1[X], D1[Y], D2[X], D2[Y],
  109.             h->orgx, h->orgy, h->clipx, h->clipy, h->shifty);
  110.         if (off)
  111.             break;
  112.         if (ddd == d) {
  113.             gr_ellipse (D2[X], D2[Y], tx, ty);
  114.         } else if (!(d%BULSTEP)) {
  115.             gr_move (D2[X]-tx, D2[Y]);
  116.             gr_draw (D2[X]+tx, D2[Y]);
  117.         }
  118.         D1[X] = D2[X];
  119.         D1[Y] = D2[Y];
  120.  
  121. /* advance 'd' to the next point.
  122. */
  123.         if (d >= BULMAX)
  124.             break;
  125.  
  126.         if (d < ddd && ddd < n)
  127.             d = ddd;
  128.         else {
  129.             d = n;
  130.             n += BULSEG;
  131.         }
  132.         first = 0;
  133.         if (d1 >= d)
  134.             goto l1;    /* point inside the same segment */
  135.     }
  136. }
  137. #undef BULSEG
  138. #undef BULSTEP
  139. #undef BULMIN
  140. #undef BULMAX
  141.